import { defineStore } from 'pinia';
import _ from 'lodash';

/**
 * 默认的本地存储名前缀
 */
const STORAGE_PREFIX = import.meta.env.VITE_STORAGE_PREFIX || 'BLESYS';

/**
 * 本地存储用户个性化数据
 */
export const useLocalStorageStore = defineStore('local_storage', () => {
    const _data = {
        /**
         * 站点相关数据
         */
        website: {
            // 页面主题颜色
            theme: '',
        },
        /**
         * 用户相关数据
         */
        user: {
            // 登录验证token
            access_token: '',
            // 备用token
            refresh_token: '',
            // 用户信息
            id: '',
            username: '',
            nickname: '',
            avatar_url: '',
            websocket: '',
        },
    };

    /**
     * 从本地存储中初始化storage对象的数据
     */
    function init() {
        for (const key in _data) {
            const value = window.localStorage.getItem(makeKey(key));
            if (!value) {
                continue;
            }

            const res = JSON.parse(value);
            _.forOwn(_data[key], (v, k, o) => {
                !_.has(res, k) || (o[k] = res[k]);
            });
        }
    }

    /**
     * 保存数据
     * @param {Object} data 键值对格式的数据
     * @param {String} rootKey 指定顶级key
     */
    function save(data, rootKey) {
        const modifedKeys = [];
        for (const key in data) {
            const [key1, key2] = find(key, rootKey);
            if (!key1) {
                // 未定义该存储项
                continue;
            }
            modifedKeys.includes(key1) || modifedKeys.push(key1);
            _data[key1][key2] = data[key];
        }
        modifedKeys.forEach(key =>
            window.localStorage.setItem(makeKey(key), JSON.stringify(_data[key]))
        );
    }

    /**
     * 删除本地存储
     * @param {String} key 要删除的存储项key
     */
    function remove(key) {
        window.localStorage.removeItem(makeKey(key));
    }

    /**
     * 清空本地存储
     */
    function clear() {
        window.localStorage.clear();
    }

    /**
     * 获取某一项存储项的值
     * @param {String} key 要查找的存储项key
     * @param {Boolean} isRoot 是否获取key指定的整个顶级存储项
     * @returns {String | Number}
     */
    function get(key, isRoot = false) {
        if (isRoot) {
            return _data[key];
        }
        let [key1, key2] = find(key);
        if (!key1) {
            // 未定义该存储项
            return undefined;
        }
        return _data[key1][key2];
    }

    /**
     * 查找某一项存储项的顶级key
     * @param {String} key 要查找的存储项key
     * @param {String} rootKey 指定顶级key，如果key中已经带了顶级key，则rootKey将被忽略
     * @returns {String}
     */
    function find(key, rootKey) {
        const [key1, key2] = key.split('.');
        if (key1 && key2) {
            // 顶级key和次级key均指定
            return validKeys([key1, key2]);
        } else if (key1 && !key2) {
            // 只指定了次级key，找出第一个匹配的顶级key
            if (rootKey) {
                return validKeys([rootKey, key]);
            }
            for (const k1 in _data) {
                for (const k2 in _data[k1]) {
                    if (k2 == key) {
                        return [k1, k2];
                    }
                }
            }
        }
        return [];
    }

    /**
     * 验证指定的存储项是否指定，如果未指定，存储项key数组将被指控
     * @param {[String, String]} keys [rootKey, subKey]
     */
    function validKeys(keys) {
        return _.has(_data, keys.join('.')) ? keys : [];
    }

    /**
     * 将key转为本地存储的名称
     */
    function makeKey(key) {
        return _.toUpper(_.snakeCase(STORAGE_PREFIX + '_' + key));
    }

    return { init, save, remove, clear, get };
});

export function setupStorage() {
    useLocalStorageStore().init();
}
